home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / tools / dvpt2.exe / UNULAW.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-12  |  3.7 KB  |  161 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*             Digitized Voice Programmer's Toolkit             */
  4. /*             ------------------------------------             */
  5. /*                                                              */
  6. /*                  Simple Mu-Law File Decoder                  */
  7. /*                                                              */
  8. /*            Copyright (c) 1991, Farpoint Software             */
  9. /*                                                              */
  10. /****************************************************************/
  11.  
  12. /* This source file is not commented, but it is relatively easy */
  13. /* to follow. This program is the complement to ULAW.C; it      */
  14. /* reverses the encoding procedure by converting each nybble to */
  15. /* a byte from a Mu-Law curve lookup table.                     */
  16.  
  17.  
  18. #include <stdlib.h>
  19. #include <fcntl.h>
  20. #include <io.h>
  21. #include <sys\types.h>
  22. #include <sys\stat.h>
  23. #include <stdio.h>
  24. #include <stddef.h>
  25. #include <malloc.h>
  26.  
  27. char logo[] = "Simple Mu-Law File Decoder\r\n"
  28.  "Copyright(c) 1991, Farpoint Software\r\n";
  29.  
  30. unsigned char *s_buffer;
  31. unsigned char *d_buffer;
  32. int s_handle,d_handle;
  33.  
  34. int utable[16] = { 0, 64, 96, 112, 120, 124, 126, 127,
  35.                    128, 129, 131, 135, 143, 159, 191, 255 };
  36.  
  37. char errmsg1[] = "File read error.";
  38. char errmsg2[] = "File write error.";
  39. char errmsg3[] = "Unable to allocate memory.";
  40.  
  41. /*-------------------------------------------------------------------*/
  42.  
  43. void main(argc,argv)
  44. int argc;
  45. char **argv;
  46.  
  47. {
  48. long s_len;
  49. unsigned int blocks, oddblock;
  50. unsigned int i, j;
  51.  
  52. puts(logo);
  53.  
  54. if (argc != 3)
  55.     {
  56.     puts("\nCommand line:");
  57.     puts(" UNULAW <source file> <dest file>\n");
  58.     exit(1);
  59.     }
  60.  
  61. argv++;
  62. s_handle = open(*argv,O_BINARY|O_RDONLY);
  63. if (s_handle == -1)
  64.     {
  65.     puts(errmsg1);
  66.     exit(1);
  67.     }
  68. argv++;
  69. d_handle = open(*argv,O_BINARY|O_RDWR|O_CREAT|O_TRUNC,S_IREAD|S_IWRITE);
  70. if (d_handle == -1)
  71.     {
  72.     close(s_handle);
  73.     puts(errmsg2);
  74.     exit(1);
  75.     }
  76.  
  77. s_buffer = (unsigned char *)malloc(16384);
  78. if (s_buffer == NULL)
  79.     {
  80.     puts(errmsg3);
  81.     close(s_handle);
  82.     close(d_handle);
  83.     exit(1);
  84.     }
  85.  
  86. d_buffer = (unsigned char *)malloc(32768U);
  87. if (d_buffer == NULL)
  88.     {
  89.     puts(errmsg3);
  90.     free(s_buffer);
  91.     close(s_handle);
  92.     close(d_handle);
  93.     exit(1);
  94.     }
  95.  
  96. s_len = filelength(s_handle);
  97.  
  98. blocks = (unsigned int)(s_len >> 14);
  99. oddblock = (unsigned int)(s_len & 0x3FFF);
  100.  
  101. for ( i = 0 ; i < blocks ; i++ )
  102.     {
  103.     if ( read(s_handle, s_buffer, 16384U) != 16384U )
  104.         {
  105.         close(s_handle);
  106.         close(d_handle);
  107.         free(s_buffer);
  108.         free(d_buffer);
  109.         puts(errmsg1);
  110.         exit(1);
  111.         }
  112.     for ( j = 0 ; j < 16384 ; j++ )
  113.         {
  114.         d_buffer[2*j] = (unsigned char)utable[s_buffer[j] & 0x0F];
  115.         d_buffer[2*j+1] = (unsigned char)utable[s_buffer[j] >> 4];
  116.         }
  117.     if ( write(d_handle, d_buffer, 32768U) != 32768U )
  118.         {
  119.         close(s_handle);
  120.         close(d_handle);
  121.         free(s_buffer);
  122.         free(d_buffer);
  123.         puts(errmsg2);
  124.         exit(1);
  125.         }
  126.     }
  127. if ( oddblock )
  128.     {
  129.     if ( (unsigned int)read(s_handle, s_buffer, oddblock) != oddblock )
  130.         {
  131.         close(s_handle);
  132.         close(d_handle);
  133.         free(s_buffer);
  134.         free(d_buffer);
  135.         puts(errmsg1);
  136.         exit(1);
  137.         }
  138.     for ( j = 0 ; j < oddblock ; j++ )
  139.         {
  140.         d_buffer[2*j] = (unsigned char)utable[s_buffer[j] & 0x0F];
  141.         d_buffer[2*j+1] = (unsigned char)utable[s_buffer[j] >> 4];
  142.         }
  143.     if ( (unsigned int)write(d_handle, d_buffer, oddblock * 2) != oddblock * 2 )
  144.         {
  145.         close(s_handle);
  146.         close(d_handle);
  147.         free(s_buffer);
  148.         free(d_buffer);
  149.         puts(errmsg2);
  150.         exit(1);
  151.         }
  152.     }
  153.  
  154. puts("File decompression complete.");
  155. close(s_handle);
  156. close(d_handle);
  157. free(s_buffer);
  158. free(d_buffer);
  159. exit(0);
  160. }
  161.